{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dispersion Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys \n",
    "import json\n",
    "import codecs\n",
    "import requests\n",
    "\n",
    "# Modify the path \n",
    "sys.path.append(\"..\")\n",
    "\n",
    "import pandas as pd\n",
    "import yellowbrick as yb\n",
    "import matplotlib.pyplot as plt "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# yellowbrick.text.dispersion\n",
    "# Implementations of lexical dispersions for text visualization.\n",
    "#\n",
    "# Author:   Larry Gray\n",
    "# Created:  2018-06-21 10:06\n",
    "#\n",
    "# Copyright (C) 2018 District Data Labs\n",
    "# For license information, see LICENSE.txt\n",
    "#\n",
    "# ID: dispersion.py [] lwgray@gmail.com $\n",
    "\n",
    "\"\"\"\n",
    "Implementation of lexical dispersion for text visualization\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "##########################################################################\n",
    "## Imports\n",
    "##########################################################################\n",
    "\n",
    "from collections import defaultdict\n",
    "import itertools\n",
    "\n",
    "from yellowbrick.text.base import TextVisualizer\n",
    "from yellowbrick.style.colors import resolve_colors\n",
    "from yellowbrick.exceptions import YellowbrickValueError\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "##########################################################################\n",
    "## Dispersion Plot Visualizer\n",
    "##########################################################################\n",
    "\n",
    "class DispersionPlot(TextVisualizer):\n",
    "    \"\"\"\n",
    "    DispersionPlotVisualizer allows for visualization of the lexical dispersion\n",
    "    of words in a corpus.  Lexical dispersion is a measure of a word's\n",
    "    homeogeneity across the parts of a corpus.  This plot notes the occurences\n",
    "    of a word and how many words from the beginning it appears.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    target_words : list\n",
    "        A list of target words whose dispersion across a corpus passed at fit\n",
    "\twill be visualized.\n",
    "\n",
    "    ax : matplotlib axes, default: None\n",
    "        The axes to plot the figure on.\n",
    "\n",
    "    labels : list of strings\n",
    "        The names of the classes in the target, used to create a legend.\n",
    "        Labels must match names of classes in sorted order.\n",
    "\n",
    "    colors : list or tuple of colors\n",
    "        Specify the colors for each individual class\n",
    "\n",
    "    colormap : string or matplotlib cmap\n",
    "        Qualitative colormap for discrete target\n",
    "\n",
    "    ignore_case : boolean, default: False\n",
    "\tSpecify whether input  will be case-sensitive.\n",
    "\n",
    "    annotate_docs : boolean, default: False\n",
    "        Specify whether document boundaries will be displayed.  Vertical lines\n",
    "        are positioned at the end of each document.\n",
    "\n",
    "    kwargs : dict\n",
    "        Pass any additional keyword arguments to the super class.\n",
    "\n",
    "    These parameters can be influenced later on in the visualization\n",
    "    process, but can and should be set as early as possible.\n",
    "    \"\"\"\n",
    "\n",
    "    # NOTE: cannot be np.nan\n",
    "    NULL_CLASS = None\n",
    "\n",
    "    def __init__(self, target_words, ax=None, colors=None, ignore_case=False,\n",
    "                 annotate_docs=False, labels=None, colormap=None, **kwargs):\n",
    "        super(DispersionPlot, self).__init__(ax=ax, **kwargs)\n",
    "\n",
    "        self.labels = labels\n",
    "        self.colors = colors\n",
    "        self.colormap = colormap\n",
    "\n",
    "        self.target_words = target_words\n",
    "        self.ignore_case = ignore_case\n",
    "        self.annotate_docs = annotate_docs\n",
    "\n",
    "    def _compute_dispersion(self, text, y):\n",
    "        self.boundaries_ = []\n",
    "        offset = 0\n",
    "\n",
    "\n",
    "        if y is None:\n",
    "            y = itertools.repeat(None)\n",
    "\n",
    "        for doc, target in zip(text, y):\n",
    "            for word in doc:\n",
    "                if self.ignore_case:\n",
    "                    word = word.lower()\n",
    "\n",
    "                # NOTE: this will find all indices if duplicate words are supplied\n",
    "                # In the case that word is not in target words, any empty list is\n",
    "                # returned and no data will be yielded\n",
    "                offset += 1\n",
    "                for y_coord in (self.indexed_words_ == word).nonzero()[0]:\n",
    "                    y_coord = int(y_coord)\n",
    "                    yield (offset, y_coord, target)\n",
    "            if self.annotate_docs:\n",
    "                self.boundaries_.append(offset)\n",
    "        self.boundaries_ = np.array(self.boundaries_, dtype=int)\n",
    "\n",
    "    def _check_missing_words(self, points):\n",
    "        for index in range(len(self.indexed_words_)):\n",
    "            if index in points[:,1]:\n",
    "                pass\n",
    "            else:\n",
    "                raise YellowbrickValueError((\n",
    "                    \"The indexed word '{}' is not found in \"\n",
    "                    \"this corpus\"\n",
    "                    ).format(self.indexed_words_[index]))\n",
    "\n",
    "    def fit(self, X, y=None, **kwargs):\n",
    "        \"\"\"\n",
    "        The fit method is the primary drawing input for the dispersion\n",
    "        visualization.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        X : list or generator\n",
    "            Should be provided as a list of documents or a generator\n",
    "            that yields a list of documents that contain a list of \n",
    "            words in the order they appear in the document.\n",
    "\n",
    "        y : ndarray or Series of length n\n",
    "            An optional array or series of target or class values for\n",
    "            instances. If this is specified, then the points will be colored\n",
    "            according to their class.\n",
    "\n",
    "        kwargs : dict\n",
    "            Pass generic arguments to the drawing method\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        self : instance\n",
    "            Returns the instance of the transformer/visualizer\n",
    "        \"\"\"\n",
    "\n",
    "        if y is not None:\n",
    "            self.classes_ = np.unique(y)\n",
    "        elif y is None and self.labels is not None:\n",
    "            self.classes_ = np.array([self.labels[0]])\n",
    "        else:\n",
    "            self.classes_ = np.array([self.NULL_CLASS])\n",
    "\n",
    "        # Create an index (e.g. the y position) for the target words\n",
    "        self.indexed_words_ = np.flip(self.target_words, axis=0)\n",
    "        if self.ignore_case:\n",
    "            self.indexed_words_ = np.array([w.lower() for w in self.indexed_words_])\n",
    "\n",
    "        # Stack is used to create a 2D array from the generator\n",
    "        try:\n",
    "            points_target = np.stack(self._compute_dispersion(X, y))\n",
    "        except ValueError:\n",
    "            raise YellowbrickValueError((\n",
    "                \"No indexed words were found in the corpus\"\n",
    "                ))\n",
    "        points = np.stack(zip(points_target[:,0].astype(int),\n",
    "                              points_target[:,1].astype(int)))\n",
    "\n",
    "        self.target = points_target[:,2]\n",
    "\n",
    "        self._check_missing_words(points)\n",
    "\n",
    "        self.draw(points, self.target)\n",
    "        return self\n",
    "\n",
    "    def draw(self, points, target=None, **kwargs):\n",
    "        \"\"\"\n",
    "        Called from the fit method, this method creates the canvas and\n",
    "        draws the plot on it.\n",
    "        Parameters\n",
    "        ----------\n",
    "        kwargs: generic keyword arguments.\n",
    "        \"\"\"\n",
    "\n",
    "        # Resolve the labels with the classes\n",
    "        labels = self.labels if self.labels is not None else self.classes_\n",
    "        if len(labels) != len(self.classes_):\n",
    "            raise YellowbrickValueError((\n",
    "                \"number of supplied labels ({}) does not \"\n",
    "                \"match the number of classes ({})\"\n",
    "            ).format(len(labels), len(self.classes_)))\n",
    "\n",
    "        # Create the color mapping for the labels.\n",
    "        color_values = resolve_colors(\n",
    "            n_colors=len(labels), colormap=self.colormap, colors=self.color)\n",
    "        colors = dict(zip(labels, color_values))\n",
    "\n",
    "        # Transform labels into a map of class to label\n",
    "        labels = dict(zip(self.classes_, labels))\n",
    "\n",
    "        # Define boundaries with a vertical line\n",
    "        if self.annotate_docs:\n",
    "            for xcoords in self.boundaries_:\n",
    "                self.ax.axvline(x=xcoords, color='lightgray', linestyle='dashed')\n",
    "\n",
    "        series = defaultdict(lambda: {'x':[], 'y':[]})\n",
    "\n",
    "        if target is not None:\n",
    "            for point, t in zip(points, target):\n",
    "                label = labels[t]\n",
    "                series[label]['x'].append(point[0])\n",
    "                series[label]['y'].append(point[1])\n",
    "        else:\n",
    "            label = self.classes_[0]\n",
    "            for x, y in points:\n",
    "                series[label]['x'].append(x)\n",
    "                series[label]['y'].append(y)\n",
    "\n",
    "        for label, points in series.items():\n",
    "            self.ax.scatter(points['x'], points['y'], marker='|',\n",
    "                            c=colors[label], zorder=100, label=label)\n",
    "\n",
    "        self.ax.set_yticks(list(range(len(self.indexed_words_))))\n",
    "        self.ax.set_yticklabels(self.indexed_words_)\n",
    "\n",
    "    def finalize(self, **kwargs):\n",
    "        \"\"\"\n",
    "        The finalize method executes any subclass-specific axes\n",
    "        finalization steps. The user calls show & show calls finalize.\n",
    "        Parameters\n",
    "        ----------\n",
    "        kwargs: generic keyword arguments.\n",
    "        \"\"\"\n",
    "\n",
    "        self.ax.set_ylim(-1, len(self.indexed_words_))\n",
    "        self.ax.set_title(\"Lexical Dispersion Plot\")\n",
    "        self.ax.set_xlabel(\"Word Offset\")\n",
    "        self.ax.grid(False)\n",
    "\n",
    "        # Add the legend outside of the figure box.\n",
    "        if not all(self.classes_ == np.array([self.NULL_CLASS])):\n",
    "            box = self.ax.get_position()\n",
    "            self.ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])\n",
    "            self.ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "\n",
    "##########################################################################\n",
    "## Quick Method\n",
    "##########################################################################\n",
    "\n",
    "def dispersion(words, corpus, y=None, ax=None, colors=None, colormap=None,\n",
    "               labels=None, annotate_docs=False, ignore_case=False, **kwargs):\n",
    "    \"\"\" Displays lexical dispersion plot for words in a corpus\n",
    "\n",
    "    This helper function is a quick wrapper to utilize the DisperstionPlot\n",
    "    Visualizer for one-off analysis\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "\n",
    "    words : list\n",
    "        A list of words whose dispersion will be examined within a corpus\n",
    "\n",
    "    y : ndarray or Series of length n\n",
    "        An optional array or series of target or class values for\n",
    "        instances. If this is specified, then the points will be colored\n",
    "        according to their class.\n",
    "\n",
    "    corpus : list\n",
    "        Should be provided as a list of documents that contain\n",
    "        a list of words in the order they appear in the document.\n",
    "\n",
    "    ax : matplotlib axes, default: None\n",
    "        The axes to plot the figure on.\n",
    "\n",
    "    labels : list of strings\n",
    "        The names of the classes in the target, used to create a legend.\n",
    "        Labels must match names of classes in sorted order.\n",
    "\n",
    "    colors : list or tuple of colors\n",
    "        Specify the colors for each individual class\n",
    "\n",
    "    colormap : string or matplotlib cmap\n",
    "        Qualitative colormap for discrete target\n",
    "\n",
    "    annotate_docs : boolean, default: False\n",
    "        Specify whether document boundaries will be displayed.  Vertical lines\n",
    "        are positioned at the end of each document.\n",
    "\n",
    "    ignore_case : boolean, default: False\n",
    "\tSpecify whether input  will be case-sensitive.\n",
    "\n",
    "    kwargs : dict\n",
    "        Pass any additional keyword arguments to the super class.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    ax: matplotlib axes\n",
    "        Returns the axes that the plot was drawn on\n",
    "    \"\"\"\n",
    "\n",
    "    # Instantiate the visualizer\n",
    "    visualizer = DispersionPlot(\n",
    "        words, ax=ax, colors=colors, colormap=colormap,\n",
    "        ignore_case=ignore_case, labels=labels,\n",
    "        annotate_docs=annotate_docs, **kwargs\n",
    "    )\n",
    "\n",
    "    # Fit and transform the visualizer (calls draw)\n",
    "    visualizer.fit(corpus, y, **kwargs)\n",
    "\n",
    "    # Return the axes object on the visualizer\n",
    "    return visualizer.ax\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "URL = \"https://raw.githubusercontent.com/foxbook/atap/master/snippets/ch08/data/oz.json\"\n",
    "\n",
    "def fetch_data(fname='oz.json'):\n",
    "    response = requests.get(URL)\n",
    "    outpath  = os.path.abspath(fname)\n",
    "    with open(outpath, 'wb') as f:\n",
    "        f.write(response.content)\n",
    "    \n",
    "    return outpath\n",
    "\n",
    "# Defining fetching data from the URL\n",
    "oz_json = fetch_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# oz.json contains a list of characters, reverse sorted by frequency\n",
    "# And a dict with {chapter title: chapter text} key-value pairs\n",
    "with codecs.open('oz.json', 'r', 'utf-8-sig') as data:\n",
    "    text = json.load(data)\n",
    "    chapters = text['chapters']\n",
    "    titles = list(chapters.keys())\n",
    "    \n",
    "    target_characters = [\"Dorothy\", \"Scarecrow\", \"Glinda\", \"Toto\", \"Witch\", \"Monkey\"]\n",
    "    chapter_text = [chap.split() for chap in chapters.values()]\n",
    "    \n",
    "    oz = DispersionPlot(target_characters, colormap='tab20b', labels=titles)\n",
    "    oz.fit(chapter_text, titles)\n",
    "    oz.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
